{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MindInsight训练看板\n",
    "\n",
    "通过MindSpore可以将训练过程中的标量、图像、参数分布直方图、张量、计算图和数据图记录到summary日志文件中，并通过MindInsight提供的可视化界面进行查看。\n",
    "\n",
    "- 通过查看特定的标量数值随着训练步骤的变化趋势，比如查看每个迭代的损失值、正确率、准确率这些标量的变化过程，追踪神经网络在整个训练过程中的信息，帮助用户了解模型是否过拟合，或者是否训练了过长时间。可以通过比较不同训练中的这些指标，以帮助调试和改善模型。\n",
    "\n",
    "- 通过查看训练过程中的图像数据，用户可以查看每个步骤所使用的数据集图像。\n",
    "\n",
    "- 参数分布直方图支持以直方图的形式呈现Tensor的变化趋势，用户可以查看训练过程中每个训练步骤的权重、bias和梯度参数变化信息。\n",
    "\n",
    "- 张量可视能够帮助用户直观查看训练过程中某个步骤的Tensor值，Tensor包括权重值、梯度值、激活值等。\n",
    "\n",
    "- 计算图的生成是通过将模型训练过程中的每个计算节点关联后所构成的，用户可以通过查看计算图，掌握整个模型的计算走向结构，数据流以及控制流的信息。对于高阶的使用人员，能够通过计算图验证计算节点的输入输出是否正确，并验证整个计算过程是否符合预期。\n",
    "\n",
    "- 数据图展示的是数据预处理的过程，在MindInsight可视化面板中可查看数据处理的图，能够更加直观地查看数据预处理的每一个环节，并帮助提升模型性能。\n",
    "\n",
    "接下来是本次流程的体验过程。\n",
    "\n",
    "## 整体流程\n",
    "\n",
    "1. 下载CIFAR-10二进制格式数据集。\n",
    "2. 对数据进行预处理。\n",
    "3. 定义AlexNet网络，在网络中使用summary算子记录数据。\n",
    "4. 训练网络，使用 `SummaryCollector` 记录损失值标量、权重梯度、计算图和数据图参数。同时启动MindInsight服务，实时查看损失值、参数直方图、输入图像、张量、计算图和数据图的变化。\n",
    "5. 完成训练后，查看MindInsight看板中记录到的损失值标量、直方图、图像信息、张量、计算图、数据图信息。\n",
    "6. 相关注意事项，关闭MindInsight服务。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 准备环节\n",
    "\n",
    "### 下载数据集\n",
    "\n",
    "本次流程使用CIFAR-10二进制格式数据集，下载地址为：<https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz>。\n",
    "\n",
    "CIFAR-10二进制格式数据集包含10个类别的60000个32x32彩色图像。每个类别6000个图像，包含50000张训练图像和10000张测试图像。数据集分为5个训练批次和1个测试批次，每个批次具有10000张图像。测试批次包含每个类别中1000个随机选择的图像，训练批次按随机顺序包含剩余图像（某个训练批次包含的一类图像可能比另一类更多）。其中，每个训练批次精确地包含对应每个类别的5000张图像。\n",
    "\n",
    "执行下面一段代码下载CIFAR-10二进制格式数据集到当前工作目录，如果已经下载过数据集，则不重复下载。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "********Checking DataSets Path.*********\n",
      "*****Downloading CIFAR-10 DataSets.*****\n",
      "*********data_batch_1.bin is ok*********\n",
      "*********data_batch_2.bin is ok*********\n",
      "*********data_batch_3.bin is ok*********\n",
      "*********data_batch_4.bin is ok*********\n",
      "*********data_batch_5.bin is ok*********\n",
      "**********test_batch.bin is ok**********\n",
      "*Downloaded CIFAR-10 DataSets Already.**\n"
     ]
    }
   ],
   "source": [
    "import os, shutil\n",
    "import urllib.request\n",
    "from urllib.parse import urlparse\n",
    "\n",
    "\n",
    "def callbackfunc(blocknum, blocksize, totalsize):\n",
    "    percent = 100.0 * blocknum * blocksize / totalsize\n",
    "    if percent > 100:\n",
    "        percent = 100\n",
    "    print(\"downloaded {:.1f}\".format(percent), end=\"\\r\")\n",
    "\n",
    "def _download_dataset():\n",
    "    ds_url = \"https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz\"\n",
    "    file_base_name = urlparse(ds_url).path.split(\"/\")[-1]\n",
    "    file_name = os.path.join(\"./datasets\", file_base_name)\n",
    "    if not os.path.exists(file_name):\n",
    "        urllib.request.urlretrieve(ds_url, file_name, callbackfunc)\n",
    "    print(\"{:*^40}\".format(\"DataSets Downloaded\"))\n",
    "    shutil.unpack_archive(file_name, extract_dir=\"./datasets/cifar-10-binary\")\n",
    "\n",
    "def _copy_dataset(ds_part, dest_path):\n",
    "    data_source_path = \"./datasets/cifar-10-binary/cifar-10-batches-bin\"\n",
    "    ds_part_source_path = os.path.join(data_source_path, ds_part)\n",
    "    if not os.path.exists(ds_part_source_path):\n",
    "        _download_dataset()\n",
    "    shutil.copy(ds_part_source_path, dest_path)\n",
    "\n",
    "def download_cifar10_dataset():\n",
    "    ds_base_path = \"./datasets/cifar10\"\n",
    "    train_path = os.path.join(ds_base_path, \"train\")\n",
    "    test_path = os.path.join(ds_base_path, \"test\")\n",
    "    print(\"{:*^40}\".format(\"Checking DataSets Path.\"))\n",
    "    if not os.path.exists(train_path) and not os.path.exists(test_path):\n",
    "        os.makedirs(train_path)\n",
    "        os.makedirs(test_path)\n",
    "    print(\"{:*^40}\".format(\"Downloading CIFAR-10 DataSets.\"))\n",
    "    for i in range(1, 6):\n",
    "        train_part = \"data_batch_{}.bin\".format(i)\n",
    "        if not os.path.exists(os.path.join(train_path, train_part)):\n",
    "            _copy_dataset(train_part, train_path)\n",
    "        pops = train_part + \" is ok\"\n",
    "        print(\"{:*^40}\".format(pops))\n",
    "    test_part = \"test_batch.bin\"\n",
    "    if not os.path.exists(os.path.join(test_path, test_part)):\n",
    "        _copy_dataset(test_part, test_path)\n",
    "    print(\"{:*^40}\".format(test_part+\" is ok\"))\n",
    "    print(\"{:*^40}\".format(\"Downloaded CIFAR-10 DataSets Already.\"))\n",
    "\n",
    "download_cifar10_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下载数据集后，CIFAR-10数据集目录（`datasets`）结构如下所示。\n",
    "\n",
    "```shell\n",
    "    $ tree datasets\n",
    "    datasets\n",
    "    └── cifar10\n",
    "        ├── test\n",
    "        │   └── test_batch.bin\n",
    "        └── train\n",
    "            ├── data_batch_1.bin\n",
    "            ├── data_batch_2.bin\n",
    "            ├── data_batch_3.bin\n",
    "            ├── data_batch_4.bin\n",
    "            └── data_batch_5.bin\n",
    "\n",
    "```\n",
    "\n",
    "其中：\n",
    "- `test_batch.bin`文件为测试数据集文件。\n",
    "- `data_batch_1.bin`文件为第1批次训练数据集文件。\n",
    "- `data_batch_2.bin`文件为第2批次训练数据集文件。\n",
    "- `data_batch_3.bin`文件为第3批次训练数据集文件。\n",
    "- `data_batch_4.bin`文件为第4批次训练数据集文件。\n",
    "- `data_batch_5.bin`文件为第5批次训练数据集文件。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据处理\n",
    "\n",
    "好的数据集可以有效提高训练精度和效率，在加载数据集前，会进行一些处理，增加数据的可用性和随机性。下面一段代码定义函数`create_dataset_cifar10`来进行数据处理操作，并创建训练数据集(`ds_train`)和测试数据集(`ds_eval`)。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.dataset as ds\n",
    "import mindspore.dataset.transforms.c_transforms as C\n",
    "import mindspore.dataset.vision.c_transforms as CV\n",
    "from mindspore import dtype as mstype\n",
    "\n",
    "\n",
    "def create_dataset_cifar10(data_path, batch_size=32, repeat_size=1, status=\"train\"):\n",
    "    \"\"\"\n",
    "    create dataset for train or test\n",
    "    \"\"\"\n",
    "    cifar_ds = ds.Cifar10Dataset(data_path)\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "\n",
    "    resize_op = CV.Resize(size=(227, 227))\n",
    "    rescale_op = CV.Rescale(rescale, shift)\n",
    "    normalize_op = CV.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "    if status == \"train\":\n",
    "        random_crop_op = CV.RandomCrop([32, 32], [4, 4, 4, 4])\n",
    "        random_horizontal_op = CV.RandomHorizontalFlip()\n",
    "    channel_swap_op = CV.HWC2CHW()\n",
    "    typecast_op = C.TypeCast(mstype.int32)\n",
    "    cifar_ds = cifar_ds.map(operations=typecast_op, input_columns=\"label\")\n",
    "    if status == \"train\":\n",
    "        cifar_ds = cifar_ds.map(operations=random_crop_op, input_columns=\"image\")\n",
    "        cifar_ds = cifar_ds.map(operations=random_horizontal_op, input_columns=\"image\")\n",
    "    cifar_ds = cifar_ds.map(operations=resize_op, input_columns=\"image\")\n",
    "    cifar_ds = cifar_ds.map(operations=rescale_op, input_columns=\"image\")\n",
    "    cifar_ds = cifar_ds.map(operations=normalize_op, input_columns=\"image\")\n",
    "    cifar_ds = cifar_ds.map(operations=channel_swap_op, input_columns=\"image\")\n",
    "\n",
    "    cifar_ds = cifar_ds.shuffle(buffer_size=1000)\n",
    "    cifar_ds = cifar_ds.batch(batch_size, drop_remainder=True)\n",
    "    cifar_ds = cifar_ds.repeat(repeat_size)\n",
    "    return cifar_ds\n",
    "\n",
    "ds_train = create_dataset_cifar10(data_path=\"./datasets/cifar10/train\")\n",
    "ds_eval = create_dataset_cifar10(\"./datasets/cifar10/test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 抽取数据集图像\n",
    "\n",
    "执行以下一段代码，抽取上步创建好的训练数据集`ds_train`中第一个`batch`的32张图像以及对应的类别名称进行展示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 32 images with label of the first batch in ds_train are showed below:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "label_list = [\"airplane\", \"automobile\", \"bird\", \"cat\", \"deer\", \"dog\", \"rog\", \"horse\", \"ship\", \"truck\"]\n",
    "print(\"The 32 images with label of the first batch in ds_train are showed below:\")\n",
    "ds_iterator = ds_train.create_dict_iterator()\n",
    "next(ds_iterator)\n",
    "batch_1 = next(ds_iterator)\n",
    "batch_image = batch_1[\"image\"].asnumpy()\n",
    "batch_label = batch_1[\"label\"].asnumpy()\n",
    "%matplotlib inline\n",
    "plt.figure(dpi=144)\n",
    "for i,image in enumerate(batch_image):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    plt.subplots_adjust(wspace=0.2, hspace=0.2)\n",
    "    image = image/np.amax(image)\n",
    "    image = np.clip(image, 0, 1)\n",
    "    image = np.transpose(image,(1,2,0))\n",
    "    plt.imshow(image)\n",
    "    num = batch_label[i]\n",
    "    plt.title(f\"image {i+1}\\n{label_list[num]}\", y=-0.65, fontdict={\"fontsize\":8})\n",
    "    plt.axis('off')    \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用Summary算子记录数据\n",
    "\n",
    "在进行训练之前，需定义神经网络模型，本流程采用AlexNet网络。\n",
    "\n",
    "MindSpore提供了两种方法进行记录数据，分别为：\n",
    "\n",
    "- 通过Summary算子记录数据。\n",
    "- 通过 `SummaryCollector` 这个callback进行记录。\n",
    "\n",
    "下面为在AlexNet网络中使用Summary算子记录输入图像和张量数据的配置方法。\n",
    "\n",
    "- 使用 `ImageSummary` 记录输入图像数据。\n",
    "\n",
    "    1. 在 `__init__` 方法中初始化 `ImageSummary`。\n",
    "        \n",
    "        ```python\n",
    "        # Init ImageSummary\n",
    "        self.image_summary = ops.ImageSummary()\n",
    "        ```\n",
    "    \n",
    "    2. 在 `construct` 方法中使用 `ImageSummary` 算子记录输入图像。其中 \"Image\" 为该数据的名称，MindInsight在展示时，会将该名称展示出来以方便识别是哪个数据。\n",
    "    \n",
    "        ```python\n",
    "        # Record image by Summary operator\n",
    "        self.image_summary(\"Image\", x)\n",
    "        ```\n",
    "        \n",
    "- 使用 `TensorSummary` 记录张量数据。\n",
    "\n",
    "    1. 在 `__init__` 方法中初始化 `TensorSummary`。\n",
    "        \n",
    "        ```python\n",
    "        # Init TensorSummary\n",
    "        self.tensor_summary = ops.TensorSummary()\n",
    "        ```\n",
    "        \n",
    "    2. 在`construct`方法中使用`TensorSummary`算子记录张量数据。其中\"Tensor\"为该数据的名称。\n",
    "    \n",
    "        ```python\n",
    "        # Record tensor by Summary operator\n",
    "        self.tensor_summary(\"Tensor\", x)\n",
    "        ```\n",
    "\n",
    "当前支持的Summary算子:\n",
    "\n",
    "- [ScalarSummary](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/ops/mindspore.ops.ScalarSummary.html): 记录标量数据\n",
    "- [TensorSummary](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/ops/mindspore.ops.TensorSummary.html): 记录张量数据\n",
    "- [ImageSummary](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/ops/mindspore.ops.ImageSummary.html): 记录图片数据\n",
    "- [HistogramSummary](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/ops/mindspore.ops.HistogramSummary.html): 将张量数据转为直方图数据记录\n",
    "\n",
    "以下一段代码中定义AlexNet网络结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.nn as nn\n",
    "from mindspore.common.initializer import TruncatedNormal\n",
    "import mindspore.ops as ops\n",
    "\n",
    "def conv(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode=\"valid\"):\n",
    "    weight = weight_variable()\n",
    "    return nn.Conv2d(in_channels, out_channels,\n",
    "                     kernel_size=kernel_size, stride=stride, padding=padding,\n",
    "                     weight_init=weight, has_bias=False, pad_mode=pad_mode)\n",
    "\n",
    "def fc_with_initialize(input_channels, out_channels):\n",
    "    weight = weight_variable()\n",
    "    bias = weight_variable()\n",
    "    return nn.Dense(input_channels, out_channels, weight, bias)\n",
    "\n",
    "def weight_variable():\n",
    "    return TruncatedNormal(0.02)\n",
    "\n",
    "\n",
    "class AlexNet(nn.Cell):\n",
    "    \"\"\"\n",
    "    Alexnet\n",
    "    \"\"\"\n",
    "    def __init__(self, num_classes=10, channel=3):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.conv1 = conv(channel, 96, 11, stride=4)\n",
    "        self.conv2 = conv(96, 256, 5, pad_mode=\"same\")\n",
    "        self.conv3 = conv(256, 384, 3, pad_mode=\"same\")\n",
    "        self.conv4 = conv(384, 384, 3, pad_mode=\"same\")\n",
    "        self.conv5 = conv(384, 256, 3, pad_mode=\"same\")\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = ops.MaxPool(ksize=3, strides=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = fc_with_initialize(6*6*256, 4096)\n",
    "        self.fc2 = fc_with_initialize(4096, 4096)\n",
    "        self.fc3 = fc_with_initialize(4096, num_classes)\n",
    "        # Init TensorSummary\n",
    "        self.tensor_summary = ops.TensorSummary()\n",
    "        # Init ImageSummary\n",
    "        self.image_summary = ops.ImageSummary()\n",
    "\n",
    "    def construct(self, x):\n",
    "        # Record image by Summary operator\n",
    "        self.image_summary(\"Image\", x)\n",
    "        x = self.conv1(x)\n",
    "        # Record tensor by Summary operator\n",
    "        self.tensor_summary(\"Tensor\", x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用 `SummaryCollector` 记录数据\n",
    "\n",
    "下面展示使用`SummaryCollector`来记录标量、直方图信息。\n",
    "\n",
    "在MindSpore中通过`Callback`机制，提供支持快速简易地收集损失值、参数权重、梯度等信息的`Callback`, 叫做`SummaryCollector`（详细的用法可以参考API文档中[mindspore.train.callback.SummaryCollector](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/mindspore.train.html#mindspore.train.callback.SummaryCollector)）。`SummaryCollector`使用方法如下： \n",
    "\n",
    "`SummaryCollector` 提供 `collect_specified_data` 参数，允许用户自定义想要收集的数据。\n",
    "\n",
    "下面的代码展示通过 `SummaryCollector` 收集损失值以及卷积层的参数值，参数值在MindInsight中以直方图展示。\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```python\n",
    "specified={\"collect_metric\": True, \"histogram_regular\": \"^conv1.*|^conv2.*\"，\"collect_graph\": True, \"collect_dataset_graph\": True}\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_01\", \n",
    "                                     collect_specified_data=specified, \n",
    "                                     collect_freq=1, \n",
    "                                     keep_default_action=False, \n",
    "                                     collect_tensor_freq=200)\n",
    "```\n",
    "\n",
    "- `summary_dir`：指定日志保存的路径。\n",
    "- `collect_specified_data`：指定需要记录的信息。\n",
    "- `collect_freq`：指定使用`SummaryCollector`记录数据的频率。\n",
    "- `keep_default_action`：指定是否除记录除指定信息外的其他数据信息。\n",
    "- `collect_tensor_freq`：指定记录张量信息的频率。\n",
    "- `\"collect_metric\"`为记录损失值标量信息。\n",
    "- `\"histogram_regular\"`为记录`conv1`层和`conv2`层直方图信息。\n",
    "- `\"collect_graph\"`为记录计算图信息。\n",
    "- `\"collect_dataset_graph\"`为记录数据图信息。\n",
    "\n",
    "&emsp;&emsp;程序运行过程中将在本地`8080`端口自动启动MindInsight服务并自动遍历读取当前notebook目录下`summary_dir`子目录下所有日志文件、解析进行可视化展示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 导入模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import mindspore.nn as nn\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor\n",
    "from mindspore.nn import Accuracy\n",
    "from mindspore.train.callback import SummaryCollector\n",
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "from mindspore import Tensor, context, Model\n",
    "\n",
    "device_target = \"GPU\"\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target=device_target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义学习率\n",
    "\n",
    "以下一段代码定义学习率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def get_lr(current_step, lr_max, total_epochs, steps_per_epoch):\n",
    "    \"\"\"\n",
    "    generate learning rate array\n",
    "\n",
    "    Args:\n",
    "       current_step(int): current steps of the training\n",
    "       lr_max(float): max learning rate\n",
    "       total_epochs(int): total epoch of training\n",
    "       steps_per_epoch(int): steps of one epoch\n",
    "\n",
    "    Returns:\n",
    "       np.array, learning rate array\n",
    "    \"\"\"\n",
    "    lr_each_step = []\n",
    "    total_steps = steps_per_epoch * total_epochs\n",
    "    decay_epoch_index = [0.8 * total_steps]\n",
    "    for i in range(total_steps):\n",
    "        if i < decay_epoch_index[0]:\n",
    "            lr = lr_max\n",
    "        else:\n",
    "            lr = lr_max * 0.1\n",
    "        lr_each_step.append(lr)\n",
    "    lr_each_step = np.array(lr_each_step).astype(np.float32)\n",
    "    learning_rate = lr_each_step[current_step:]\n",
    "\n",
    "    return learning_rate\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 执行训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 1, loss is 2.3037791\n",
      "epoch: 1 step: 2, loss is 2.3127236\n",
      "epoch: 1 step: 3, loss is 2.3156757\n",
      "epoch: 1 step: 4, loss is 2.2910595\n",
      "epoch: 1 step: 5, loss is 2.3042145\n",
      "epoch: 1 step: 6, loss is 2.3150084\n",
      "epoch: 1 step: 7, loss is 2.2808924\n",
      "epoch: 1 step: 8, loss is 2.3073373\n",
      "epoch: 1 step: 9, loss is 2.308782\n",
      "epoch: 1 step: 10, loss is 2.2957213\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 10 step: 1550, loss is 0.54039395\n",
      "epoch: 10 step: 1551, loss is 0.25690028\n",
      "epoch: 10 step: 1552, loss is 0.26572403\n",
      "epoch: 10 step: 1553, loss is 0.4429163\n",
      "epoch: 10 step: 1554, loss is 0.25716054\n",
      "epoch: 10 step: 1555, loss is 0.38538748\n",
      "epoch: 10 step: 1556, loss is 0.12103356\n",
      "epoch: 10 step: 1557, loss is 0.16565521\n",
      "epoch: 10 step: 1558, loss is 0.4364005\n",
      "epoch: 10 step: 1559, loss is 0.428179\n",
      "epoch: 10 step: 1560, loss is 0.42687342\n",
      "epoch: 10 step: 1561, loss is 0.6419081\n",
      "epoch: 10 step: 1562, loss is 0.5843237\n",
      "Epoch time: 115283.798, per step time: 73.805\n",
      "============== Starting Testing ==============\n",
      "============== {'Accuracy': 0.8302283653846154} ==============\n"
     ]
    }
   ],
   "source": [
    "network = AlexNet(num_classes=10)\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "lr = Tensor(get_lr(0, 0.002, 10, ds_train.get_dataset_size()))\n",
    "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
    "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
    "ckpoint_cb = ModelCheckpoint(directory=\"./models/ckpt/mindinsight_dashboard\", prefix=\"checkpoint_alexnet\", config=config_ck)\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()})\n",
    "\n",
    "summary_base_dir = \"./summary_dir\"\n",
    "os.system(f\"mindinsight start --summary-base-dir  {summary_base_dir} --port=8080\")\n",
    "\n",
    "# Init a SummaryCollector callback instance, and use it in model.train or model.eval\n",
    "specified = {\"collect_metric\": True, \"histogram_regular\": \"^conv1.*|^conv2.*\", \"collect_graph\": True, \"collect_dataset_graph\": True}\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_01\", collect_specified_data=specified, collect_freq=1, keep_default_action=False, collect_tensor_freq=200)\n",
    "\n",
    "print(\"============== Starting Training ==============\")\n",
    "model.train(epoch=10, train_dataset=ds_train, callbacks=[time_cb, ckpoint_cb, LossMonitor(), summary_collector], dataset_sink_mode=True)\n",
    "\n",
    "print(\"============== Starting Testing ==============\")\n",
    "param_dict = load_checkpoint(\"./models/ckpt/mindinsight_dashboard/checkpoint_alexnet-10_1562.ckpt\")\n",
    "load_param_into_net(network, param_dict)\n",
    "acc = model.eval(ds_eval, callbacks=summary_collector, dataset_sink_mode=True)\n",
    "print(\"============== {} ==============\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MindInsight看板\n",
    "\n",
    "在本地浏览器中打开地址：`127.0.0.1:8080`，进入到可视化面板。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/mindinsight_panel.png)\n",
    "\n",
    "在上图所示面板中可以看到`summary_01`日志文件目录，点击**训练看板**进入到下图所示的训练数据展示面板，该面板展示了标量数据、直方图、图像和张量信息，并随着训练、测试的进行实时刷新数据，实时显示训练过程参数的变化情况。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/mindinsight_panel2.png)\n",
    "\n",
    "### 标量可视化\n",
    "\n",
    "标量可视化用于展示训练过程中标量的变化趋势，点击打开训练标量信息展示面板，该面板记录了迭代计算过程中的损失值标量信息，如下图展示了损失值标量趋势图。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/scalar_panel.png)\n",
    "\n",
    "上图展示了神经网络在训练过程中损失值的变化过程。横坐标是训练步骤，纵坐标是损失值。\n",
    "\n",
    "图中右上角有几个按钮功能，从左到右功能分别是全屏展示，切换Y轴比例，开启/关闭框选，分步回退和还原图形。\n",
    "\n",
    "- 全屏展示即全屏展示该标量曲线，再点击一次即可恢复。\n",
    "- 切换Y轴比例是指可以将Y轴坐标进行对数转换。\n",
    "- 开启/关闭框选是指可以框选图中部分区域，并放大查看该区域，可以在已放大的图形上叠加框选。\n",
    "- 分步回退是指对同一个区域连续框选并放大查看时，可以逐步撤销操作。\n",
    "- 还原图形是指进行了多次框选后，点击此按钮可以将图还原回原始状态。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/scalar_select.png)\n",
    "\n",
    "上图展示的标量可视化的功能区，提供了根据选择不同标签，水平轴的不同维度和平滑度来查看标量信息的功能。\n",
    "\n",
    "- 标签选择：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的标量信息。\n",
    "- 水平轴：可以选择“步骤”、“相对时间”、“绝对时间”中的任意一项，来作为标量曲线的水平轴。\n",
    "- 平滑度：可以通过调整平滑度，对标量曲线进行平滑处理。\n",
    "- 标量合成：可以选中两条标量曲线进行合成并展示在一个图中，以方便对两条曲线进行对比或者查看合成后的图。\n",
    "  标量合成的功能区与标量可视化的功能区相似。其中与标量可视化功能区不一样的地方，在于标签选择时，标量合成功能最多只能同时选择两个标签，将其曲线合成并展示。\n",
    "\n",
    "### 直方图可视化\n",
    "\n",
    "\n",
    "直方图用于将用户所指定的张量以直方图的形式展示。点击打开直方图展示面板，以直方图的形式记录了在迭代过程中所有层参数分布信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram_panel.png)\n",
    "\n",
    "如下图为`conv1`层参数分布信息，点击图中右上角，可以将图放大。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram.png)\n",
    "\n",
    "下图为直方图功能区。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram_func.png)\n",
    "\n",
    "上图展示直方图的功能区，包含以下内容：\n",
    "\n",
    "- 标签选择：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的直方图。\n",
    "- 纵轴：可以选择步骤、相对时间、绝对时间中的任意一项，来作为直方图纵轴显示的数据。\n",
    "- 视角：可以选择正视和俯视中的一种。正视是指从正面的角度查看直方图，此时不同步骤之间的数据会覆盖在一起。俯视是指偏移以45度角俯视直方图区域，这时可以呈现不同步骤之间数据的差异。\n",
    "\n",
    "### 图像可视化\n",
    "\n",
    "图像可视化用于展示用户所指定的图片。点击数据抽样展示面板，展示了每个一步进行处理的图像信息。\n",
    "\n",
    "下图为展示`summary_01`记录的图像信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/image_panel.png)\n",
    "\n",
    "通过滑动上图中的\"步骤\"滑条，查看不同步骤的图片。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/image_function.png)\n",
    "\n",
    "上图展示图像可视化的功能区，提供了选择查看不同标签，不同亮度和不同对比度来查看图片信息。\n",
    "\n",
    "- 标签：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的图片信息。\n",
    "- 亮度调整：可以调整所展示的所有图片亮度。\n",
    "- 对比度调整：可以调整所展示的所有图片对比度。\n",
    "\n",
    "### 张量可视化\n",
    "\n",
    "张量可视化用于将张量以表格以及直方图的形式进行展示。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/tensor_func.png)\n",
    "\n",
    "上图展示了张量可视化的功能区，包含以下内容：\n",
    "\n",
    "- 标签选择：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的表格数据或者直方图。\n",
    "- 视图：可以选择表格或者直方图来展示tensor数据。在直方图视图下存在纵轴和视角的功能选择。\n",
    "- 纵轴：可以选择步骤、相对时间、绝对时间中的任意一项，来作为直方图纵轴显示的数据。\n",
    "- 视角：可以选择正视和俯视中的一种。正视是指从正面的角度查看直方图，此时不同步骤之间的数据会覆盖在一起。俯视是指 偏移以45度角俯视直方图区域，这时可以呈现不同步骤之间数据的差异。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/tensor.png)\n",
    "\n",
    "上图中将用户所记录的张量以表格的形式展示，包含以下功能：\n",
    "\n",
    "- 点击表格右边小方框按钮，可以将表格放大。\n",
    "- 表格中白色方框显示当前展示的是哪个维度下的张量数据，其中冒号\":\"表示当前维度的所有值，可以在方框输入对应的索引或者:后按Enter键或者点击后边的打勾按钮来查询特定维度的张量数据。 假设某维度是32，则其索引范围是-32到31。注意：可以查询0维到2维的张量数据，不支持查询超过两维的张量数据，即不能设置超过两个冒号\":\"的查询条件。\n",
    "- 拖拽表格下方的空心圆圈可以查询特定步骤的张量数据。\n",
    "\n",
    "### 计算图可视化\n",
    "\n",
    "点击计算图可视化用于展示计算图的图结构，数据流以及控制流的走向，支持展示summary日志文件与通过`context`的`save_graphs`参数导出的`pb`文件。\n",
    "\n",
    "![graph.png](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/caculate_graph.png)\n",
    "\n",
    "上展示了计算图的网络结构。如图中所展示的，在展示区中，选中其中一个算子（图中圈红算子），可以看到该算子有两个输入和一个输出（实线代表算子的数据流走向）。\n",
    "\n",
    "![graph_sidebar.png](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/graph_sidebar.png)\n",
    "\n",
    "上图展示了计算图可视化的功能区，包含以下内容：\n",
    "\n",
    "- 文件选择框：可以选择查看不同文件的计算图。\n",
    "- 搜索框：可以对节点进行搜索，输入节点名称点击回车，即可展示该节点。\n",
    "- 缩略图：展示整个网络图结构的缩略图，在查看超大图结构时，方便查看当前浏览的区域。\n",
    "- 节点信息：展示选中的节点的基本信息，包括节点的名称、属性、输入节点、输出节点等信息。\n",
    "- 图例：展示的是计算图中各个图标的含义。\n",
    "\n",
    "### 数据图可视化\n",
    "\n",
    "数据图可视化用于展示单次模型训练的数据处理和数据增强信息。\n",
    "\n",
    "![data_function.png](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/data_function.png)\n",
    "\n",
    "上图展示的数据图功能区包含以下内容：\n",
    "\n",
    "- 图例：展示数据溯源图中各个图标的含义。\n",
    "- 数据处理流水线：展示训练所使用的数据处理流水线，可以选择图中的单个节点查看详细信息。\n",
    "- 节点信息：展示选中的节点的基本信息，包括使用的数据处理和增强算子的名称、参数等。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 单独记录损失值标量\n",
    "\n",
    "\n",
    "为了降低性能开销和日志文件大小，可以单独记录关心的数据。单独记录标量、参数分布直方图、计算图或数据图信息，可以通过配置`specified`参数为相应的值来单独记录。单独记录图像或张量信息，可以在AlexNet网络的`construct`方法中使用`ImageSummary`算子或`TensorSummary`算子来单独记录。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关闭MindInsight服务\n",
    "\n",
    "在终端命令行中执行以下代码关闭MindInsight服务。\n",
    "\n",
    "```shell\n",
    "mindinsight stop --port 8080\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 注意事项和规格\n",
    "1. 为了控制列出summary文件目录的用时，MindInsight最多支持发现999个summary文件目录。\n",
    "2. 不能同时使用多个 `SummaryRecord` 实例 （`SummaryCollector` 中使用了 `SummaryRecord`）。\n",
    "\n",
    "    如果在 `model.train` 或者 `model.eval` 的callback列表中使用两个及以上的 `SummaryCollector` 实例，则视为同时使用 `SummaryRecord`，导致记录数据失败。\n",
    "\n",
    "    自定义callback中如果使用 `SummaryRecord`，则其不能和 `SummaryCollector` 同时使用。\n",
    "\n",
    "    正确代码:\n",
    "    ```\n",
    "    ...\n",
    "    summary_collector = SummaryCollector('./summary_dir')\n",
    "    model.train(2, train_dataset, callbacks=[summary_collector])\n",
    "\n",
    "    ...\n",
    "    model.eval(dataset， callbacks=[summary_collector])\n",
    "    ```\n",
    "\n",
    "    错误代码：\n",
    "    ```\n",
    "    ...\n",
    "    summary_collector1 = SummaryCollector('./summary_dir1')\n",
    "    summary_collector2 = SummaryCollector('./summary_dir2')\n",
    "    model.train(2, train_dataset, callbacks=[summary_collector1, summary_collector2])\n",
    "    ```\n",
    "\n",
    "    错误代码：\n",
    "    ```\n",
    "    ...\n",
    "    # Note: the 'ConfusionMatrixCallback' is user-defined, and it uses SummaryRecord to record data.\n",
    "    confusion_callback = ConfusionMatrixCallback('./summary_dir1')\n",
    "    summary_collector = SummaryCollector('./summary_dir2')\n",
    "    model.train(2, train_dataset, callbacks=[confusion_callback, summary_collector])\n",
    "    ```\n",
    "3. 每个summary日志文件目录中，应该只放置一次训练的数据。一个summary日志目录中如果存放了多次训练的summary数据，MindInsight在可视化数据时会将这些训练的summary数据进行叠加展示，可能会与预期可视化效果不相符。\n",
    "4. 当前 `SummaryCollector` 和 `SummaryRecord` 不支持GPU多卡运行的场景。\n",
    "5. 目前MindSpore仅支持在Ascend 910 AI处理器上导出算子融合后的计算图。\n",
    "6. 在训练中使用Summary算子收集数据时，`HistogramSummary` 算子会影响性能，所以请尽量少地使用。\n",
    "7. 为了控制内存占用，MindInsight对标签（tag）数目和步骤（step）数目进行了限制：\n",
    "    - 每个训练看板的最大标签数量为300个标签。标量标签、图片标签、计算图标签、参数分布图（直方图）标签、张量标签的数量总和不得超过300个。特别地，每个训练看板最多有10个计算图标签、6个张量标签。当实际标签数量超过这一限制时，将依照MindInsight的处理顺序，保留最近处理的300个标签。\n",
    "    - 每个训练看板的每个标量标签最多有1000个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "    - 每个训练看板的每个图片标签最多有10个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "    - 每个训练看板的每个参数分布图（直方图）标签最多有50个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "    - 每个训练看板的每个张量标签最多有20个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "8. 由于`TensorSummary`会记录完整Tensor数据，数据量通常会比较大，为了控制内存占用和出于性能上的考虑，MindInsight对Tensor的大小以及返回前端展示的数值个数进行以下限制：\n",
    "    - MindInsight最大支持加载含有1千万个数值的Tensor。\n",
    "    - Tensor加载后，在张量可视的表格视图下，最大支持查看10万个数值，如果所选择的维度查询得到的数值超过这一限制，则无法显示。\n",
    "\n",
    "9. 由于张量可视（`TensorSummary`）会记录原始张量数据，需要的存储空间较大。使用`TensorSummary`前和训练过程中请注意检查系统存储空间充足。\n",
    "\n",
    "    通过以下方法可以降低张量可视功能的存储空间占用：\n",
    "\n",
    "    1）避免使用`TensorSummary`记录较大的Tensor。\n",
    "\n",
    "    2）减少网络中`TensorSummary`算子的使用个数。\n",
    "\n",
    "   功能使用完毕后，请及时清理不再需要的训练日志，以释放磁盘空间。\n",
    "\n",
    "   备注：估算`TensorSummary`空间使用量的方法如下：\n",
    "\n",
    "   一个`TensorSummary数据的大小 ＝ Tensor中的数值个数 * 4 bytes`。假设使用`TensorSummary`记录的Tensor大小为`32 * 1 * 256 * 256`，则一个`TensorSummary`数据大约需要`32 * 1 * 256 * 256 * 4 bytes = 8,388,608 bytes = 8MiB`。`TensorSummary`默认会记录20个步骤的数据，则记录这20组数据需要的空间约为`20 * 8 MiB ＝ 160MiB`。需要注意的是，由于数据结构等因素的开销，实际使用的存储空间会略大于160MiB。\n",
    "10. 当使用`TensorSummary`时，由于记录完整Tensor数据，训练日志文件较大，MindInsight需要更多时间解析训练日志文件，请耐心等待。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "本次体验流程为完整的MindSpore深度学习及MindInsight可视化展示的过程，包括了下载数据集及预处理过程，构建网络、损失函数和优化器过程，生成模型并进行训练、验证的过程，以及启动MindInsight服务进行训练过程可视化展示。读者可以基于本次体验流程构建自己的网络模型进行训练，并使用`SummaryCollector`以及Summary算子记录关心的数据，然后在MindInsight服务看板中进行可视化展示，根据MindInsight服务中展示的结果调整相应的参数以提高训练精度。\n",
    "\n",
    "以上便完成了标量、直方图、图像和张量可视化的体验，我们通过本次体验全面了解了MindSpore执行训练的过程和MindInsight在标量、直方图、图像、张量、计算图和数据图可视化的应用，理解了如何使用`SummaryColletor`记录训练过程中的标量、直方图、图像、张量、计算图和数据图数据。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}